home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / CodeWarrior Lite / Metrowerks C⁄C++ Lite / Headers / System Extras Headers / MacTCP Headers / AddressXlation.h next >
Encoding:
C/C++ Source or Header  |  1995-03-09  |  13.3 KB  |  337 lines  |  [TEXT/MMCC]
  1. /*
  2.      File:        AddressXlation.h
  3.  
  4.      Contains:    TCP Manager interfaces for dnr.c
  5.  
  6.      Version:    Use with MacTCP 2.0.6 and Universal Interfaces 2.1b1
  7.                     in “MPW Prerelease” on ETO #17
  8.  
  9.       Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, send the file and version
  13.                  information (from above) and the problem description to:
  14.  
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. */
  19.  
  20. #ifndef __ADDRESSXLATION__
  21. #define __ADDRESSXLATION__
  22.  
  23.  
  24. #ifndef __TYPES__
  25. #include <Types.h>
  26. #endif
  27. /*    #include <ConditionalMacros.h>                                */
  28.  
  29. #ifndef __MACTCP__
  30. #include <MacTCP.h>
  31. #endif
  32. /*    #include <AppleTalk.h>                                        */
  33. /*        #include <OSUtils.h>                                    */
  34. /*            #include <MixedMode.h>                                */
  35. /*            #include <Memory.h>                                    */
  36.  
  37. #ifdef __cplusplus
  38. extern "C" {
  39. #endif
  40.  
  41. #if STRUCTALIGNMENTSUPPORTED
  42. #pragma options align=mac68k
  43. #endif
  44.  
  45. #if PRAGMA_IMPORT_SUPPORTED
  46. #pragma import on
  47. #endif
  48.  
  49. /*
  50.     Developer Notes:
  51.  
  52.             When the various calls are made to the dnr code, you must set up 
  53.             a NewRoutineDescriptor for every non-nil completion routine and/or 
  54.             notifyProc parameter.  Otherwise, the 68K dnr code, will not 
  55.             correctly call your routine.
  56.         1. For the call to EnumCache, use NewEnumResultProc to set up a 
  57.             universal procptr to pass as the enumResultProc parameter.
  58.         2. For the calls to StrToAddr and AddrToName, use NewResultProc to 
  59.             set up a ResultUPP universal procptr to pass as the ResultProc 
  60.             parameter.
  61.         3. For the calls to HInfo and MXInfo, use NewResultProc2Proc to
  62.             set up a ResultProc2UPP universal procptr to pass as the ResultProc
  63.             parameter.
  64.         4. The DNR selector symbol HINFO has been changed to HXINFO due to
  65.             conflict with the same symbol in the AddressXLation.h header
  66. */
  67.  
  68. enum {
  69.     NUM_ALT_ADDRS                = 4
  70. };
  71.  
  72. struct hostInfo {
  73.     long                            rtnCode;
  74.     char                            cname[255];
  75.     SInt8                            filler;                        /* Filler for proper byte alignment     */
  76.     unsigned long                    addr[NUM_ALT_ADDRS];
  77. };
  78. typedef struct hostInfo hostInfo;
  79.  
  80.  
  81. enum {
  82.     A                            = 1,
  83.     NS                            = 2,
  84.     CNAME                        = 5,
  85.     HINFO                        = 13,
  86.     MX                            = 15,
  87.     lastClass                    = 32767
  88. };
  89.  
  90. typedef unsigned short AddrClasses;
  91.  
  92. /* Domain Name Resolver code selectors */
  93.  
  94. enum {
  95.     OPENRESOLVER                = 1,
  96.     CLOSERESOLVER                = 2,
  97.     STRTOADDR                    = 3,
  98.     ADDRTOSTR                    = 4,
  99.     ENUMCACHE                    = 5,
  100.     ADDRTONAME                    = 6,
  101.     HXINFO                        = 7,                            /* changed from HINFO due to symbol conflict*/
  102.     MXINFO                        = 8
  103. };
  104.  
  105. struct HInfoRec {
  106.     char                            cpuType[30];
  107.     char                            osType[30];
  108. };
  109. typedef struct HInfoRec HInfoRec;
  110.  
  111. struct MXRec {
  112.     unsigned short                    preference;
  113.     char                            exchange[255];
  114. };
  115. typedef struct MXRec MXRec;
  116.  
  117. struct returnRec {
  118.     long                            rtnCode;
  119.     char                            cname[255];
  120.     SInt8                            filler;                        /* Filler for proper byte alignment     */
  121.     union {
  122.         unsigned long                    addr[NUM_ALT_ADDRS];
  123.         struct HInfoRec                    hinfo;
  124.         struct MXRec                    mx;
  125.     }                                rdata;
  126. };
  127. typedef struct returnRec returnRec;
  128.  
  129. struct cacheEntryRecord {
  130.     char                            *cname;
  131.     unsigned short                    ctype;
  132.     unsigned short                    cacheClass;
  133.     unsigned long                    ttl;
  134.     union {
  135.         char                            *name;
  136.         ip_addr                            addr;
  137.     }                                rdata;
  138. };
  139. typedef struct cacheEntryRecord cacheEntryRecord;
  140.  
  141. typedef pascal void (*EnumResultProcPtr)(struct cacheEntryRecord *cacheEntryRecordPtr, Ptr userDataPtr);
  142. typedef pascal void (*ResultProcPtr)(struct hostInfo *hostInfoPtr, Ptr userDataPtr);
  143. typedef pascal void (*ResultProc2ProcPtr)(struct returnRec *returnRecPtr, Ptr userDataPtr);
  144.  
  145. #if GENERATINGCFM
  146. typedef UniversalProcPtr EnumResultUPP;
  147. typedef UniversalProcPtr ResultUPP;
  148. typedef UniversalProcPtr ResultProc2UPP;
  149. #else
  150. typedef EnumResultProcPtr EnumResultUPP;
  151. typedef ResultProcPtr ResultUPP;
  152. typedef ResultProc2ProcPtr ResultProc2UPP;
  153. #endif
  154.  
  155. enum {
  156.     uppEnumResultProcInfo = kPascalStackBased
  157.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct cacheEntryRecord*)))
  158.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr))),
  159.     uppResultProcInfo = kPascalStackBased
  160.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct hostInfo*)))
  161.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr))),
  162.     uppResultProc2ProcInfo = kPascalStackBased
  163.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct returnRec*)))
  164.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr)))
  165. };
  166.  
  167. #if GENERATINGCFM
  168. #define NewEnumResultProc(userRoutine)        \
  169.         (EnumResultUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppEnumResultProcInfo, GetCurrentArchitecture())
  170. #define NewResultProc(userRoutine)        \
  171.         (ResultUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppResultProcInfo, GetCurrentArchitecture())
  172. #define NewResultProc2Proc(userRoutine)        \
  173.         (ResultProc2UPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppResultProc2ProcInfo, GetCurrentArchitecture())
  174. #else
  175. #define NewEnumResultProc(userRoutine)        \
  176.         ((EnumResultUPP) (userRoutine))
  177. #define NewResultProc(userRoutine)        \
  178.         ((ResultUPP) (userRoutine))
  179. #define NewResultProc2Proc(userRoutine)        \
  180.         ((ResultProc2UPP) (userRoutine))
  181. #endif
  182.  
  183. #if GENERATINGCFM
  184. #define CallEnumResultProc(userRoutine, cacheEntryRecordPtr, userDataPtr)        \
  185.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppEnumResultProcInfo, (cacheEntryRecordPtr), (userDataPtr))
  186. #define CallResultProc(userRoutine, hostInfoPtr, userDataPtr)        \
  187.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppResultProcInfo, (hostInfoPtr), (userDataPtr))
  188. #define CallResultProc2Proc(userRoutine, returnRecPtr, userDataPtr)        \
  189.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppResultProc2ProcInfo, (returnRecPtr), (userDataPtr))
  190. #else
  191. #define CallEnumResultProc(userRoutine, cacheEntryRecordPtr, userDataPtr)        \
  192.         (*(userRoutine))((cacheEntryRecordPtr), (userDataPtr))
  193. #define CallResultProc(userRoutine, hostInfoPtr, userDataPtr)        \
  194.         (*(userRoutine))((hostInfoPtr), (userDataPtr))
  195. #define CallResultProc2Proc(userRoutine, returnRecPtr, userDataPtr)        \
  196.         (*(userRoutine))((returnRecPtr), (userDataPtr))
  197. #endif
  198.  
  199. extern OSErr OpenResolver(char *fileName);
  200. extern OSErr StrToAddr(char *hostName, struct hostInfo *hostInfoPtr, ResultUPP ResultProc, char *userDataPtr);
  201. extern OSErr AddrToStr(unsigned long addr, char *addrStr);
  202. extern OSErr EnumCache(EnumResultUPP enumResultProc, Ptr userDataPtr);
  203. extern OSErr AddrToName(ip_addr addr, struct hostInfo *hostInfoPtr, ResultUPP ResultProc, Ptr userDataPtr);
  204. extern OSErr HInfo(char *hostName, struct returnRec *returnRecPtr, ResultProc2UPP resultProc, Ptr userDataPtr);
  205. extern OSErr MXInfo(char *hostName, struct returnRec *returnRecPtr, ResultProc2UPP resultProc, Ptr userDataPtr);
  206. extern OSErr CloseResolver(void);
  207. /*
  208.     Universal ProcPtrs declaration for each of the dnr selector code calls.
  209. */
  210. typedef OSErr (*OpenResolverProcPtr)(UInt32 selector, char *filename);
  211. typedef OSErr (*CloseResolverProcPtr)(UInt32 selector);
  212. typedef OSErr (*StrToAddrProcPtr)(UInt32 selector, char *hostName, struct hostInfo *rtnStruct, ResultUPP resultproc, Ptr userDataPtr);
  213. typedef OSErr (*AddrToStrProcPtr)(UInt32 selector, unsigned long addr, char *addrStr);
  214. typedef OSErr (*EnumCacheProcPtr)(UInt32 selector, EnumResultUPP resultproc, Ptr userDataPtr);
  215. typedef OSErr (*AddrToNameProcPtr)(UInt32 selector, UInt32 addr, struct hostInfo *rtnStruct, ResultUPP resultproc, Ptr userDataPtr);
  216. typedef OSErr (*HInfoProcPtr)(UInt32 selector, char *hostName, struct returnRec *returnRecPtr, ResultProc2UPP resultProc, Ptr userDataPtr);
  217. typedef OSErr (*MXInfoProcPtr)(UInt32 selector, char *hostName, struct returnRec *returnRecPtr, ResultProc2UPP resultProc, Ptr userDataPtr);
  218.  
  219. #if GENERATINGCFM
  220. typedef UniversalProcPtr OpenResolverUPP;
  221. typedef UniversalProcPtr CloseResolverUPP;
  222. typedef UniversalProcPtr StrToAddrUPP;
  223. typedef UniversalProcPtr AddrToStrUPP;
  224. typedef UniversalProcPtr EnumCacheUPP;
  225. typedef UniversalProcPtr AddrToNameUPP;
  226. typedef UniversalProcPtr HInfoUPP;
  227. typedef UniversalProcPtr MXInfoUPP;
  228. #else
  229. typedef OpenResolverProcPtr OpenResolverUPP;
  230. typedef CloseResolverProcPtr CloseResolverUPP;
  231. typedef StrToAddrProcPtr StrToAddrUPP;
  232. typedef AddrToStrProcPtr AddrToStrUPP;
  233. typedef EnumCacheProcPtr EnumCacheUPP;
  234. typedef AddrToNameProcPtr AddrToNameUPP;
  235. typedef HInfoProcPtr HInfoUPP;
  236. typedef MXInfoProcPtr MXInfoUPP;
  237. #endif
  238.  
  239. enum {
  240.     uppOpenResolverProcInfo = kCStackBased
  241.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  242.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
  243.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*))),
  244.     uppCloseResolverProcInfo = kCStackBased
  245.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  246.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32))),
  247.     uppStrToAddrProcInfo = kCStackBased
  248.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  249.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
  250.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*)))
  251.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(struct hostInfo*)))
  252.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(ResultUPP)))
  253.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Ptr))),
  254.     uppAddrToStrProcInfo = kCStackBased
  255.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  256.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
  257.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(unsigned long)))
  258.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(char*))),
  259.     uppEnumCacheProcInfo = kCStackBased
  260.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  261.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
  262.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(EnumResultUPP)))
  263.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Ptr))),
  264.     uppAddrToNameProcInfo = kCStackBased
  265.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  266.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
  267.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(UInt32)))
  268.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(struct hostInfo*)))
  269.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(ResultUPP)))
  270.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Ptr))),
  271.     uppHInfoProcInfo = kCStackBased
  272.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  273.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
  274.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*)))
  275.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(struct returnRec*)))
  276.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(ResultProc2UPP)))
  277.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Ptr))),
  278.     uppMXInfoProcInfo = kCStackBased
  279.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  280.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
  281.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*)))
  282.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(struct returnRec*)))
  283.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(ResultProc2UPP)))
  284.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Ptr)))
  285. };
  286.  
  287. #if GENERATINGCFM
  288. #define CallOpenResolverProc(userRoutine, selector, filename)        \
  289.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppOpenResolverProcInfo, (selector), (filename))
  290. #define CallCloseResolverProc(userRoutine, selector)        \
  291.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppCloseResolverProcInfo, (selector))
  292. #define CallStrToAddrProc(userRoutine, selector, hostName, rtnStruct, resultproc, userDataPtr)        \
  293.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppStrToAddrProcInfo, (selector), (hostName), (rtnStruct), (resultproc), (userDataPtr))
  294. #define CallAddrToStrProc(userRoutine, selector, addr, addrStr)        \
  295.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppAddrToStrProcInfo, (selector), (addr), (addrStr))
  296. #define CallEnumCacheProc(userRoutine, selector, resultproc, userDataPtr)        \
  297.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppEnumCacheProcInfo, (selector), (resultproc), (userDataPtr))
  298. #define CallAddrToNameProc(userRoutine, selector, addr, rtnStruct, resultproc, userDataPtr)        \
  299.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppAddrToNameProcInfo, (selector), (addr), (rtnStruct), (resultproc), (userDataPtr))
  300. #define CallHInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userDataPtr)        \
  301.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppHInfoProcInfo, (selector), (hostName), (returnRecPtr), (resultProc), (userDataPtr))
  302. #define CallMXInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userDataPtr)        \
  303.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppMXInfoProcInfo, (selector), (hostName), (returnRecPtr), (resultProc), (userDataPtr))
  304. #else
  305. #define CallOpenResolverProc(userRoutine, selector, filename)        \
  306.         (*(userRoutine))((selector), (filename))
  307. #define CallCloseResolverProc(userRoutine, selector)        \
  308.         (*(userRoutine))((selector))
  309. #define CallStrToAddrProc(userRoutine, selector, hostName, rtnStruct, resultproc, userDataPtr)        \
  310.         (*(userRoutine))((selector), (hostName), (rtnStruct), (resultproc), (userDataPtr))
  311. #define CallAddrToStrProc(userRoutine, selector, addr, addrStr)        \
  312.         (*(userRoutine))((selector), (addr), (addrStr))
  313. #define CallEnumCacheProc(userRoutine, selector, resultproc, userDataPtr)        \
  314.         (*(userRoutine))((selector), (resultproc), (userDataPtr))
  315. #define CallAddrToNameProc(userRoutine, selector, addr, rtnStruct, resultproc, userDataPtr)        \
  316.         (*(userRoutine))((selector), (addr), (rtnStruct), (resultproc), (userDataPtr))
  317. #define CallHInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userDataPtr)        \
  318.         (*(userRoutine))((selector), (hostName), (returnRecPtr), (resultProc), (userDataPtr))
  319. #define CallMXInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userDataPtr)        \
  320.         (*(userRoutine))((selector), (hostName), (returnRecPtr), (resultProc), (userDataPtr))
  321. #endif
  322.  
  323.  
  324. #if PRAGMA_IMPORT_SUPPORTED
  325. #pragma import off
  326. #endif
  327.  
  328. #if STRUCTALIGNMENTSUPPORTED
  329. #pragma options align=reset
  330. #endif
  331.  
  332. #ifdef __cplusplus
  333. }
  334. #endif
  335.  
  336. #endif /* __ADDRESSXLATION__ */
  337.